एसिंक्रोनस प्रोग्रामिंग क्या है?
Node.js , I/O .
यह निर्बाध दृष्टिकोण Node.js को हजारों समवर्ती कनेक्शनों को कुशलतापूर्वक संभालने में मदद करता है।
तुल्यकालन
गतिविधि पूरी होने तक अवरुद्ध करता है
समझना आसान है
देरी का कारण बन रहा है
readFileSync जैसे फ़ंक्शंस का उपयोग करता है
अतुल्यकालिक
निर्बाध संचालन
उत्कृष्ट प्रदर्शन
इससे निपटना बहुत जटिल है
कॉलबैक, वादे या एसिंक/प्रतीक्षा का उपयोग करना
सिंक्रोनस बनाम एसिंक्रोनस: उदाहरण
सिंक्रोनाइज़ेशन फ़ाइल स्टेपिंग
const fs = require('fs');
console.log('1. Starting sync read...');
const data = fs.readFileSync('myfile.txt', 'utf8');
console.log('2. File contents:', data);
console.log('3. Done reading file');आउटपुट अनुक्रम है: 1 → 2 → 3 (प्रत्येक चरण के बीच अवरोधन)
अतुल्यकालिक फ़ाइल स्थानांतरण
const fs = require('fs');
console.log('1. Starting async read...');
fs.readFile('myfile.txt', 'utf8', (err, data) => {
if (err) throw err;
console.log('2. File contents:', data);
});
console.log('3. Done starting read operation');आउटपुट क्रम: 1 → 3 → 2 (फ़ाइल के चरणबद्ध होने की प्रतीक्षा नहीं करता)
कॉलबैक नरक से बचना
समस्या: नेस्टेड कॉलबैक (कॉलबैक नरक)
getUser(userId, (err, user) => {
if (err) return handleError(err);
getOrders(user.id, (err, orders) => {
if (err) return handleError(err);
processOrders(orders, (err) => {
if (err) return handleError(err);
console.log('All done!');
});
});
});समाधान: वादों का प्रयोग करें
getUser(userId)
.then(user => getOrders(user.id))
.then(orders => processOrders(orders))
.then(() => console.log('All done!'))
.catch(handleError);और भी बेहतर: Async/प्रतीक्षा करें
async function processUser(userId) {
try {
const user = await getUser(userId);
const orders = await getOrders(user.id);
await processOrders(orders);
console.log('All done!');
} catch (err) {
handleError(err);
}
}आधुनिक अतुल्यकालिक विधियाँ
1. वादे
const fs = require('fs').promises;
console.log('1. Reading file...');
fs.readFile('myfile.txt', 'utf8')
.then(data => {
console.log('3. File content:', data);
})
.catch(err => console.error('Error:', err));
console.log('2. This runs before file is read!');2. Async/प्रतीक्षा (अनुशंसित)
async function readFiles() {
try {
console.log('1. Starting to read files...');
const data1 = await fs.readFile('file1.txt', 'utf8');
const data2 = await fs.readFile('file2.txt', 'utf8');
console.log('2. Files read successfully!');
return { data1, data2 };
} catch (error) {
console.error('Error reading files:', error);
}
}सर्वोत्तम अभ्यास
इसे करें
// Use async/await for better readability
async function getUserData(userId) {
try {
const user = await User.findById(userId);
const orders = await Order.find({ userId });
return { user, orders };
} catch (error) {
console.error('Failed to fetch user data:', error);
throw error; // Re-throw or handle appropriately
}
}ऐसा मत करो
// Nested callbacks are hard to read and maintain
User.findById(userId, (err, user) => {
if (err) return console.error(err);
Order.find({ userId }, (err, orders) => {
if (err) return console.error(err);
// Process orders...
});
});महत्वपूर्ण टिप्पणियाँ:
- बेहतर पठनीयता के लिए async/प्रतीक्षा का उपयोग करें
- कोशिश/पकड़ के साथ त्रुटियों को संभालते समय
- Promise.all
- सिंक्रोनस और एसिंक्रोनस कोड मोड को मिश्रित न करें
- वादों का इंतजार करना न भूलें
समानांतर संचालन
उदाहरण: समानांतर संचालन
// Run multiple async operations in parallel
async function fetchAllData() {
try {
const [users, products, orders] = await Promise.all([
User.find(),
Product.find(),
Order.find()
]);
return { users, products, orders };
} catch (error) {
console.error('Error fetching data:', error);
throw error;
}
}Promise.all , .
एसिंक्रोनस कोड का उपयोग क्यों करें?
एसिंक्रोनस कोड Node.js को फ़ाइल या डेटाबेस एक्सेस जैसे धीमे संचालन की प्रतीक्षा किए बिना एक साथ कई अनुरोधों को संभालने की अनुमति देता है।
यह Node.js को सर्वर और रीयल-टाइम अनुप्रयोगों के लिए आदर्श बनाता है।
उच्च प्रदर्शन
एक साथ कई अनुरोधों को संभालता है
अनुमापकता
कम संसाधनों में अधिक कनेक्शन संभालता है
त्वरित प्रतिक्रिया
धीमे I/O संचालन की प्रतीक्षा नहीं करता
वास्तविक समय अनुप्रयोग
चैट, गेम और सहयोग टूल के लिए आदर्श
सारांश
Node.js I/O
आधुनिक एसिंक्रोनस कोड वादों के साथ एसिंक/प्रतीक्षा का उपयोग करता है
अतुल्यकालिक संचालन में त्रुटियों को संभालते समय
समानांतर संचालन के लिए Promise.all का उपयोग करें
उचित अतुल्यकालिक तरीकों से कॉलबैक नरक से बचें
महत्वपूर्ण बिंदु:
- Async/प्रतीक्षा पठनीयता में सुधार करती है
- Promise.all
- वादे कॉलबैक की तुलना में बेहतर संरचना प्रदान करते हैं
- त्रुटि प्रबंधन कब लागू करें
- निर्बाध I/O Node.js की एक प्रमुख ताकत है
अभ्यास
सही शब्द चुनें।
Node.js I/O ______एक प्रोग्रामिंग मॉडल का उपयोग करता है.